{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 分类模型结果分析"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Platform : win32 [win32/linux]\n",
      "Systerm  : 3.6.10 (default, Mar  5 2020, 10:17:47) [MSC v.1900 64 bit (AMD64)] \n",
      "numpy  Version: 1.16.0\n",
      "pandas Version: 1.0.4\n",
      "sklearn Version: 0.23.2\n"
     ]
    }
   ],
   "source": [
    "import os \n",
    "import sys\n",
    "import re\n",
    "import copy\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from pandas import DataFrame\n",
    "\n",
    "import sklearn\n",
    "from sklearn.metrics import classification_report,confusion_matrix\n",
    "from sklearn.metrics import precision_score,recall_score,f1_score,accuracy_score\n",
    "from sklearn.metrics import precision_recall_curve\n",
    "from sklearn.metrics import average_precision_score\n",
    "from sklearn.metrics import roc_curve, auc   \n",
    "from sklearn.preprocessing import LabelBinarizer  \n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib as mpl\n",
    "mpl.rcParams['font.sans-serif'] = [u'simHei']\n",
    "mpl.rcParams['axes.unicode_minus'] = False\n",
    "\n",
    "###   关闭 sklearn 的报警信息\n",
    "import warnings\n",
    "warnings.filterwarnings(action=\"ignore\",module='sklearn')\n",
    "\n",
    "print('Platform : {} [win32/linux]'.format(sys.platform))  # 当前平台信息 \n",
    "print('Systerm  : {} '.format(sys.version))\n",
    "print('numpy  Version: {}'.format(np.__version__))\n",
    "print('pandas Version: {}'.format(pd.__version__))\n",
    "print('sklearn Version: {}'.format(sklearn.__version__))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "###  结果分析报告程序\n",
    "class ResultReport(object):\n",
    "    '''\n",
    "    #### 初始化\n",
    "    __init__(self,Y_True0,Y_Predict,Y_Predict_proba,ModelName='TEST_01_01',FolderName=None)    \n",
    "    \n",
    "    #### 预测分析报告打印  PrintFlag为True时打印到本地窗口，False时后台打印，此时可选ROC、PR、CM\n",
    "    ReportPrint(self,PrintFlag=True,digits=4,ROC_Flag=True,PR_Flag=True,CM_Flag=True)\n",
    "\n",
    "    #### 计算AUC 值，画出ROC曲线\n",
    "    ROC(self,PrintFlag=True)     \n",
    "\n",
    "    ### 查准率 precision -查全率 Recall 曲线图\n",
    "    PR(self,PrintFlag=True)\n",
    "        \n",
    "    #### 计算混淆矩阵，画出混淆矩阵图\n",
    "    Confusion_matrix(self,PrintFlag=True)\n",
    "    '''\n",
    "    \n",
    "    #### 初始化\n",
    "    def __init__(self,Y_True0,Y_Predict,Y_Predict_proba,ModelName='TEST_01_01',FolderName=None):\n",
    "        '''\n",
    "        Y_True0  :真实值   列表、DataFrame、np\n",
    "        Y_Predict:预测值   numpy.ndarray   \n",
    "        Y_Predict_proba: 预测概率值矩阵\n",
    "        ModelName :模型名称，用于保存文件名\n",
    "        FolderName :图片保存文件夹名称\n",
    "        '''\n",
    "        ## 复制标签值、将标签值转化为DataFrame格式\n",
    "        Y_True=DataFrame(copy.deepcopy(Y_True0))\n",
    "        Y_True.columns=['Label']  ## 属性列名为Label\n",
    "        ## 真实值\n",
    "        self.Y_True=Y_True\n",
    "        ## 预测标签值\n",
    "        self.Y_Predict=Y_Predict\n",
    "        ## 预测标签概率矩阵\n",
    "        self.Y_Predict_proba=Y_Predict_proba\n",
    "        ## 模型名称\n",
    "        self.ModelName=ModelName\n",
    "        \n",
    "        ## 多分类二值化 将标签值转化为 Onehot矩阵\n",
    "        LabelBin=LabelBinarizer().fit(self.Y_True)\n",
    "        self.Y_True_Bin=LabelBin.transform(self.Y_True)\n",
    "        ## 标签值列表\n",
    "        self.Label=LabelBin.classes_\n",
    "        \n",
    "        ## 类别数量\n",
    "        self.n_class=len(self.Label)  ## 类别数量        \n",
    "        ## 若只有两个类别时，LabelBinarizer 转化后只有一列数值，将其拆分为两列\n",
    "        if self.n_class==2:\n",
    "            Y_True_Bin_new=np.zeros([self.Y_True_Bin.shape[0],2],dtype=self.Y_True_Bin.dtype)\n",
    "            Y_True_Bin_new[self.Y_True_Bin.T[0]==0,0]=1 ## 第 0 列\n",
    "            Y_True_Bin_new[self.Y_True_Bin.T[0]==1,1]=1 ## 第 1 列\n",
    "            self.Y_True_Bin=Y_True_Bin_new\n",
    "            \n",
    "        ## 准确率  average='weighted'  加权平均\n",
    "        self.Precision=precision_score(Y_True,Y_Predict,average='weighted')\n",
    "        ## 召回率  average='weighted'  加权平均\n",
    "        self.Recall=recall_score(Y_True,Y_Predict,average='weighted')\n",
    "        ## f1_score  average='weighted'  加权平均\n",
    "        self.F1=f1_score(Y_True,Y_Predict,average='weighted')\n",
    "        ## 准确度值\n",
    "        self.accuracy=accuracy_score(Y_True,Y_Predict)\n",
    "        \n",
    "        ## 图片保存文件夹\n",
    "        if FolderName:\n",
    "            self.FilePath=os.path.join(os.getcwd(),FolderName)\n",
    "        else:\n",
    "            self.FilePath=os.getcwd()\n",
    "        \n",
    "    #### 预测分析报告打印  PrintFlag为True时打印到本地窗口，False时后台打印，此时可选ROC、PR、CM\n",
    "    def ReportPrint(self,PrintFlag=True,digits=4,ROC_Flag=True,PR_Flag=True,CM_Flag=True):\n",
    "        '''\n",
    "        PrintFlag :是否打印到本地窗口 标志位\n",
    "        digits  :浮点数值有效位\n",
    "        ROC_Flag :是否计算ROC曲线\n",
    "        PR_Flag  :是否计算PR曲线\n",
    "        CM_Flag  :是否计算混淆矩阵\n",
    "        '''\n",
    "        ## 预测结果分析表\n",
    "        Report=classification_report(self.Y_True,self.Y_Predict,digits=digits)\n",
    "        ## 打印到本地窗口\n",
    "        if PrintFlag:\n",
    "            print('-'*60)\n",
    "            print('',self.ModelName)\n",
    "            print(Report)\n",
    "            print('-'*60)    \n",
    "        else : #输出，待打印到表格中 【主要用于模型批量分析】\n",
    "            ## 去除空格以便后续操作\n",
    "            Report=re.sub('avg / total','avg/total',Report)\n",
    "            ## 按 空格 换行符拆开  首行Title 删除\n",
    "            Report=[line_i.split() for line_i in Report.split('\\n')[1:] if len(line_i.split())>0]\n",
    "            ## 重新合并 \n",
    "            Report='\\n'.join([','.join(self.ModelName.split('_')+ [self.ModelName]+line_i)  for line_i in Report])\n",
    "            \n",
    "            ## 是否计算 ROC 曲线\n",
    "            if ROC_Flag:\n",
    "                self.ROC(PrintFlag=False)\n",
    "                ## 总的AUC 值\n",
    "                AUC_all=self.ROC_Curve[3][self.n_class]\n",
    "            else:\n",
    "                AUC_all=0\n",
    "\n",
    "            ## 是否计算PR曲线，\n",
    "            if PR_Flag:\n",
    "                self.PR(PrintFlag=False) \n",
    "                ## 总的PR 值\n",
    "                PR_all=self.PR_Curve[3][self.n_class]\n",
    "            else:\n",
    "                PR_all=0\n",
    "\n",
    "            ## 是否计算混淆矩阵\n",
    "            if CM_Flag:\n",
    "                self.Confusion_matrix(PrintFlag=False) \n",
    "\n",
    "            self.Report='%s,%.4f,%.4f'%(Report,AUC_all,PR_all)\n",
    "            \n",
    "    #### 计算AUC 值，画出ROC曲线\n",
    "    def ROC(self,PrintFlag=True):\n",
    "        '''\n",
    "        PrintFlag=True :是否打印到本窗口标志\n",
    "        图像数据保存在 self.ROC_Curve=[fpr,tpr,thresholds,Auc]   中\n",
    "        '''\n",
    "        fpr = dict() \n",
    "        tpr = dict()\n",
    "        thresholds=dict()\n",
    "        Auc=dict()\n",
    "\n",
    "        ## 计算每个类别的假阳性率、真阳性率,AUC 值\n",
    "        for i in range(self.n_class):\n",
    "            fpr[i], tpr[i], thresholds[i] = roc_curve(self.Y_True_Bin[:, i],self.Y_Predict_proba[:, i])\n",
    "            Auc[i]=auc(fpr[i], tpr[i])   \n",
    "            \n",
    "        ##  计算 总的假阳性率、真阳性率 ,AUC 值\n",
    "        fpr[i+1], tpr[i+1], thresholds[i+1] = roc_curve(self.Y_True_Bin.ravel(),self.Y_Predict_proba.ravel())\n",
    "        Auc[i+1]=auc(fpr[i+1], tpr[i+1])      \n",
    "        \n",
    "        ## ROC 曲线的所有相关值保存 \n",
    "        self.ROC_Curve=[fpr,tpr,thresholds,Auc]  \n",
    "\n",
    "        plt.figure(figsize=(16,10))\n",
    "        \n",
    "        ## 画出每个类别的ROC曲线\n",
    "        for i in range(self.n_class): \n",
    "            plt.plot(fpr[i], tpr[i],alpha=0.8,\n",
    "                     lw=3, label='Class %s ROC curve (area = %0.3f)' % (self.Label[i],Auc[i]))\n",
    "        \n",
    "        ## 画出总的ROC曲线\n",
    "        plt.plot(fpr[i+1], tpr[i+1], linestyle='-',color='red',\n",
    "                 lw=6, label='   ALL   ROC curve (area = %0.3f)' % (Auc[i+1]))\n",
    "        \n",
    "        plt.plot([0, 1], [0, 1], color='navy', lw=3, linestyle='--',alpha=0.5)\n",
    "        plt.xlim([-0.02, 1.0])\n",
    "        plt.ylim([0.0, 1.03])\n",
    "        plt.xlabel('FPR(False Positive Rate) 假正率',fontsize=30)\n",
    "        plt.ylabel('TPR(True Positive Rate) 真正率',fontsize=30)\n",
    "        plt.title('%s-ROC曲线图'%(self.ModelName),fontsize=45)\n",
    "        plt.legend(loc=\"lower right\",fontsize=20)\n",
    "        plt.xticks( fontsize=20) \n",
    "        plt.yticks(fontsize=20)\n",
    "        plt.grid(b=True, ls=':')\n",
    "        plt.subplots_adjust(wspace=0.1,hspace=0.2,top=0.9,right=0.985,left=0.05,bottom=0.05) #图片边缘设置\n",
    "        \n",
    "        if PrintFlag:\n",
    "            plt.show()\n",
    "        else:\n",
    "            plt.savefig(os.path.join(self.FilePath,'%s_ROC曲线图.png'%(self.ModelName)),dpi=300,bbox_inches='tight')\n",
    "        plt.close()\n",
    "        \n",
    "    ### 查准率 precision -查全率 Recall 曲线图\n",
    "    def PR(self,PrintFlag=True):\n",
    "        '''\n",
    "        PrintFlag=True :是否打印到本窗口标志\n",
    "        图像数据保存在 self.PR_Curve=[precision,recall,thresholds,average_precision]   中        \n",
    "        '''\n",
    "        precision = dict()\n",
    "        recall = dict()\n",
    "        thresholds=dict()\n",
    "        average_precision = dict()\n",
    "        ## 计算每个类别 的 PR 值 \n",
    "        for i in range(self.n_class):\n",
    "            precision[i], recall[i], thresholds[i] = precision_recall_curve(self.Y_True_Bin[:, i],self.Y_Predict_proba[:, i])\n",
    "            average_precision[i] = average_precision_score(self.Y_True_Bin[:, i], self.Y_Predict_proba[:, i])\n",
    "            \n",
    "        ## 计算所有类别总的PR值\n",
    "        precision[i+1], recall[i+1], thresholds[i+1] = precision_recall_curve(self.Y_True_Bin.ravel(),self.Y_Predict_proba.ravel())\n",
    "        average_precision[i+1] = average_precision_score(self.Y_True_Bin.ravel(), self.Y_Predict_proba.ravel())\n",
    "            \n",
    "        ## PR 曲线的所有相关值保存 \n",
    "        self.PR_Curve=[precision,recall,thresholds,average_precision]\n",
    "\n",
    "        plt.figure(figsize=(16,10))\n",
    "        \n",
    "        ## 画出每个类别的 P~R 曲线\n",
    "        for i in range(self.n_class): \n",
    "            plt.plot(recall[i], precision[i],alpha=0.8,\n",
    "                     lw=3, label='Class %s P-R curve (area = %0.3f)' % (self.Label[i],average_precision[i]))\n",
    "\n",
    "        ## 画出总的 P~R 曲线\n",
    "        plt.plot(recall[i+1], precision[i+1], linestyle='-',color='red',\n",
    "                 lw=6, label='   ALL   P-R curve (area = %0.3f)' % (average_precision[i+1]))\n",
    "        \n",
    "        plt.plot([0,1], [0,1], color='navy', lw=3, linestyle='--',alpha=0.5)\n",
    "        plt.xlim([0.0, 1.02])\n",
    "        plt.ylim([0.0, 1.03])\n",
    "        plt.xlabel('Recall 召回率、查全率',fontsize=30)\n",
    "        plt.ylabel('Precision 准确率、查准率',fontsize=30)\n",
    "        plt.title('%s P-R曲线图'%(self.ModelName),fontsize=45)\n",
    "        plt.legend(loc=\"lower left\",fontsize=20)\n",
    "        plt.xticks( fontsize=20) \n",
    "        plt.yticks(fontsize=20)\n",
    "        plt.grid(b=True, ls=':')\n",
    "        plt.subplots_adjust(wspace=0.1,hspace=0.2,top=0.9,right=0.985,left=0.05,bottom=0.05) #图片边缘设置\n",
    "        \n",
    "        if PrintFlag:\n",
    "            plt.show()\n",
    "        else:\n",
    "            plt.savefig(os.path.join(self.FilePath,'%s_PR曲线图.png'%(self.ModelName)),dpi=300,bbox_inches='tight')\n",
    "        plt.close()\n",
    "         \n",
    "    #### 计算混淆矩阵，画出混淆矩阵图\n",
    "    def Confusion_matrix(self,PrintFlag=True):\n",
    "        '''\n",
    "        PrintFlag=True :是否打印到本窗口标志\n",
    "        self.Confu_Matrix=Confu_Matrix  :混淆矩阵\n",
    "        self.Confu_Matrix_revise=Confu_Matrix_revise :除去各类别数量后对应比例值\n",
    "        '''        \n",
    "        ## 计算混淆矩阵\n",
    "        Confu_Matrix=confusion_matrix(self.Y_True,self.Y_Predict)\n",
    "        self.Confu_Matrix=Confu_Matrix\n",
    "         \n",
    "        ## 各个类别数量\n",
    "        Label_No=self.Y_True.groupby('Label')['Label'].count()\n",
    "        ##  除以各个类别样本数，得到对应比例\n",
    "        Confu_Matrix_revise=(Confu_Matrix.T/Label_No.values).T\n",
    "        self.Confu_Matrix_revise=Confu_Matrix_revise\n",
    "        \n",
    "        ## 画图\n",
    "        plt.figure(figsize=(16,10))           \n",
    "        plt.imshow(Confu_Matrix_revise,cmap='Reds',aspect='auto',alpha=0.8)   \n",
    "        plt.plot([0,len(Label_No)-1],[0,len(Label_No)-1],'g:',alpha=0.6)\n",
    "        plt.title('%s-混淆矩阵图'%(self.ModelName),fontsize=45)           \n",
    "        plt.xlabel('类别 预测值',fontsize=30)\n",
    "        plt.ylabel('类别 实际值',fontsize=30)\n",
    "        plt.xticks( range(len(Label_No)), Label_No.index ,fontsize=20)\n",
    "        plt.yticks( range(len(Label_No)), Label_No.index ,fontsize=20)\n",
    "        ## 各个类别预测样本数量\n",
    "        for i,Confu_Matrix_i in enumerate(Confu_Matrix):\n",
    "            for j,Confu_Matrix_i_j in enumerate(Confu_Matrix_i):\n",
    "                plt.text(j,i,'%d'%(Confu_Matrix_i_j),fontsize=200/self.n_class, horizontalalignment='center',verticalalignment='center')\n",
    "            \n",
    "        plt.subplots_adjust(wspace=0.1,hspace=0.2,top=0.9,right=0.985,left=0.05,bottom=0.05) #图片边缘设置\n",
    "        if PrintFlag:\n",
    "            plt.show()\n",
    "        else:            \n",
    "            plt.savefig(os.path.join(self.FilePath,'%s_混淆矩阵图.png'%(self.ModelName)),dpi=300,bbox_inches='tight')\n",
    "        plt.close()\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "------------------------------------------------------------\n",
      " TEST_01\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           B     0.9677    1.0000    0.9836        30\n",
      "           C     1.0000    1.0000    1.0000        10\n",
      "           D     1.0000    0.9833    0.9916        60\n",
      "\n",
      "    accuracy                         0.9900       100\n",
      "   macro avg     0.9892    0.9944    0.9917       100\n",
      "weighted avg     0.9903    0.9900    0.9900       100\n",
      "\n",
      "------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "############################  生成测试样例  \n",
    "from sklearn.datasets import make_classification\n",
    "X, Y = make_classification(n_samples=100,n_features=50,n_informative=3,n_redundant=2, \n",
    "                           n_classes=3,weights=[0.6,0.3,0.1],random_state=1)  #\n",
    "\n",
    "X=DataFrame(X)                               \n",
    "Y=DataFrame(Y,columns=['Label'])\n",
    "Y[Y==0]='D'\n",
    "Y[Y==1]='B'\n",
    "Y[Y==2]='C'\n",
    "\n",
    "############################   模型预测\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "Model=DecisionTreeClassifier(max_depth=3)\n",
    "Model.fit(X,Y)\n",
    "\n",
    "Y_Predict=Model.predict(X)\n",
    "Y_Predict_proba=Model.predict_proba(X)\n",
    "\n",
    "\n",
    "############################   调用分析\n",
    "### 调用分类结果分析报告类\n",
    "Report=ResultReport(Y,Y_Predict,Y_Predict_proba,ModelName='TEST_01',FolderName='Result')\n",
    "\n",
    "## 画出 ROC曲线 \n",
    "Report.ROC()\n",
    "## 画出 PR曲线     \n",
    "Report.PR()\n",
    "## 画出 混淆矩阵图\n",
    "Report.Confusion_matrix()\n",
    "\n",
    "## 打印 分类结果报告 PrintFlag为 True时打印到窗口  为False时后台运算并输出结果字符串\n",
    "Report.ReportPrint(PrintFlag=True,ROC_Flag=True,PR_Flag=True,CM_Flag=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "PY36-tf12",
   "language": "python",
   "name": "py36_b"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
